FishMarket 1.0/FishMarket v1.0.iso/fishies/176-200/disk_197/stevie/alloc.c

C/C++ Source or Header | 1992-05-06 | 5KB | 211 lines

/*
 * STEVIE - Simply Try this Editor for VI Enthusiasts
 *
 * Code Contributions By : Tim Thompson           twitch!tjt
 *                         Tony Andrews           onecom!wldrdg!tony
 *                         G. R. (Fred) Walter    watmath!watcgl!grwalter
 */

#include "stevie.h"

/*
 * This file contains various routines dealing with allocation and
 * deallocation of data structures.
 */

char           *
alloc(size)
    unsigned        size;
{
    char           *p;        /* pointer to new storage space */
#ifdef AMIGA
    char           *pp;

    /*
     * Before allocating any memory make sure there is enough for a system
     * requester left.
     */
    pp = malloc((unsigned) 40000);
    if (pp == (char *) NULL) {    /* if there is no more room... */
    emsg("alloc() is unable to find memory!");
    return (NULL);
    }
#endif

    p = malloc(size);
    if (p == (char *) NULL)    /* if there is no more room... */
    emsg("alloc() is unable to find memory!");

#ifdef AMIGA
    free(pp);
#endif
    return (p);
}

char           *
strsave(string)
    char           *string;
{
    return (strcpy(alloc((unsigned) (strlen(string) + 1)), string));
}

void
screenalloc()
{
    int             i;

    /*
     * If we're changing the size of the screen, free the old arrays
     */
    if (Realscreen != NULL)
    free(Realscreen);
    if (Nextscreen != NULL)
    free(Nextscreen);
    if (LinePointers != NULL)
    free((char *) LinePointers);
    if (LineSizes != NULL)
    free(LineSizes);

    Realscreen = malloc((unsigned) (Rows * Columns));
    Nextscreen = malloc((unsigned) (Rows * Columns));
    LinePointers = (LINE **) malloc((unsigned) (Rows * sizeof(LINE *)));
    LineSizes = malloc((unsigned) Rows);

    for (i = 0; i < Rows; i++) {
    LinePointers[i] = NULL;
    LineSizes[i] = 0;
    }
}

/*
 * Allocate and initialize a new line structure with room for 'nchars'
 * characters.
 */
LINE           *
newline(nchars)
    int             nchars;
{
    register LINE  *l;

    l = (LINE *) alloc((unsigned) sizeof(LINE));
    if (l == NULL)
    return (LINE *) NULL;

    l->s = alloc((unsigned) nchars);    /* the line is empty */
    l->s[0] = NUL;
    l->size = nchars;

    l->prev = (LINE *) NULL;    /* should be initialized by caller */
    l->next = (LINE *) NULL;

    return l;
}

/*
 * filealloc() - construct an initial empty file buffer
 */
void
filealloc()
{
    if ((Filemem->linep = newline(1)) == NULL) {
    fprintf(stderr, "Unable to allocate file memory!\n");
    getout(1);
    }
    if ((Filetop->linep = newline(1)) == NULL) {
    fprintf(stderr, "Unable to allocate file memory!\n");
    getout(1);
    }
    if ((Fileend->linep = newline(1)) == NULL) {
    fprintf(stderr, "Unable to allocate file memory!\n");
    getout(1);
    }
    Filemem->index = 0;
    Filetop->index = 0;
    Fileend->index = 0;

    Filetop->linep->prev = NULL;
    Filetop->linep->next = Filemem->linep;    /* connect Filetop to Filemem */
    Filemem->linep->prev = Filetop->linep;

    Filemem->linep->next = Fileend->linep;    /* connect Filemem to Fileend */
    Fileend->linep->prev = Filemem->linep;
    Fileend->linep->next = NULL;

    *Curschar = *Filemem;
    *Topchar = *Filemem;

    Filemem->linep->num = 0;
    Fileend->linep->num = 0xffffffffL;

    clrall();            /* clear all marks */
}

/*
 * freeall() - free the current buffer
 *
 * Free all lines in the current buffer.
 */
void
freeall()
{
    LINE           *lp;
    LINE           *xlp;
    int             i;

    for (lp = Filetop->linep; lp != NULL; lp = xlp) {
    if (lp->s != NULL)
        free(lp->s);
    xlp = lp->next;
    free((char *) lp);
    }

    Curschar->linep = NULL;    /* clear pointers */
    Filemem->linep = NULL;
    Filetop->linep = NULL;
    Fileend->linep = NULL;

    for (i = 0; i < Rows; i++) {/* clear screen information */
    LinePointers[i] = NULL;
    LineSizes[i] = 0;
    }
}

/*
 * canincrease(n) - returns TRUE if the current line can be increased 'n'
 * bytes
 *
 * This routine returns immediately if the requested space is available. If not,
 * it attempts to allocate the space and adjust the data structures
 * accordingly. If everything fails it returns FALSE.
 */
bool_t
canincrease(n)
    register int    n;
{
    register int    nsize;
    register char  *s;        /* pointer to new space */

    nsize = strlen(Curschar->linep->s) + 1 + n;    /* size required */

    if (nsize <= Curschar->linep->size)
    return TRUE;

    /*
     * Need to allocate more space for the string. Allow some extra space on
     * the assumption that we may need it soon. This avoids excessive numbers
     * of calls to malloc while entering new text.
     */
    s = alloc((unsigned) (nsize + SLOP));
    if (s == NULL) {
    emsg("Can't add anything, file is too big!");
    State = NORMAL;
    return FALSE;
    }
    Curschar->linep->size = nsize + SLOP;
    strcpy(s, Curschar->linep->s);
    free(Curschar->linep->s);
    Curschar->linep->s = s;

    return TRUE;
}